{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Title: #First Day Where You Have Been in All the Rooms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difficulty: #Medium"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Category Title: #Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tag Slug: #array #dynamic-programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name Translated: #数组 #动态规划"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution Name: firstDayBeenInAllRooms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Title: #访问完所有房间的第一天"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Content:\n",
    "<p>你需要访问&nbsp;<code>n</code> 个房间，房间从 <code>0</code> 到 <code>n - 1</code> 编号。同时，每一天都有一个日期编号，从 <code>0</code> 开始，依天数递增。你每天都会访问一个房间。</p>\n",
    "\n",
    "<p>最开始的第 <code>0</code> 天，你访问&nbsp;<code>0</code> 号房间。给你一个长度为 <code>n</code> 且 <strong>下标从 0 开始</strong> 的数组 <code>nextVisit</code> 。在接下来的几天中，你访问房间的 <strong>次序</strong> 将根据下面的 <strong>规则</strong> 决定：</p>\n",
    "\n",
    "<ul>\n",
    "\t<li>假设某一天，你访问&nbsp;<code>i</code> 号房间。</li>\n",
    "\t<li>如果算上本次访问，访问&nbsp;<code>i</code> 号房间的次数为 <strong>奇数</strong> ，那么 <strong>第二天</strong> 需要访问&nbsp;<code>nextVisit[i]</code> 所指定的房间，其中 <code>0 &lt;= nextVisit[i] &lt;= i</code> 。</li>\n",
    "\t<li>如果算上本次访问，访问&nbsp;<code>i</code> 号房间的次数为 <strong>偶数</strong> ，那么 <strong>第二天</strong> 需要访问&nbsp;<code>(i + 1) mod n</code> 号房间。</li>\n",
    "</ul>\n",
    "\n",
    "<p>请返回你访问完所有房间的第一天的日期编号。题目数据保证总是存在这样的一天。由于答案可能很大，返回对 <code>10<sup>9</sup> + 7</code> 取余后的结果。</p>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><strong>示例 1：</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入：</strong>nextVisit = [0,0]\n",
    "<strong>输出：</strong>2\n",
    "<strong>解释：</strong>\n",
    "- 第 0 天，你访问房间 0 。访问 0 号房间的总次数为 1 ，次数为奇数。\n",
    "&nbsp; 下一天你需要访问房间的编号是 nextVisit[0] = 0\n",
    "- 第 1 天，你访问房间 0 。访问 0 号房间的总次数为 2 ，次数为偶数。\n",
    "&nbsp; 下一天你需要访问房间的编号是 (0 + 1) mod 2 = 1\n",
    "- 第 2 天，你访问房间 1 。这是你第一次完成访问所有房间的那天。\n",
    "</pre>\n",
    "\n",
    "<p><strong>示例 2：</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入：</strong>nextVisit = [0,0,2]\n",
    "<strong>输出：</strong>6\n",
    "<strong>解释：</strong>\n",
    "你每天访问房间的次序是 [0,0,1,0,0,1,2,...] 。\n",
    "第 6 天是你访问完所有房间的第一天。\n",
    "</pre>\n",
    "\n",
    "<p><strong>示例 3：</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入：</strong>nextVisit = [0,1,2,0]\n",
    "<strong>输出：</strong>6\n",
    "<strong>解释：</strong>\n",
    "你每天访问房间的次序是 [0,0,1,1,2,2,3,...] 。\n",
    "第 6 天是你访问完所有房间的第一天。\n",
    "</pre>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><strong>提示：</strong></p>\n",
    "\n",
    "<ul>\n",
    "\t<li><code>n == nextVisit.length</code></li>\n",
    "\t<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>\n",
    "\t<li><code>0 &lt;= nextVisit[i] &lt;= i</code></li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Description: [first-day-where-you-have-been-in-all-the-rooms](https://leetcode.cn/problems/first-day-where-you-have-been-in-all-the-rooms/description/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solutions: [first-day-where-you-have-been-in-all-the-rooms](https://leetcode.cn/problems/first-day-where-you-have-been-in-all-the-rooms/solutions/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = ['[0,0]', '[0,0,2]', '[0,1,2,0]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        # 到达第x+1房间需要先到达第x房间两次，第一次到达x后需要额外一天到达nextVisit[x]，从nextVisit[x]到达x可以用他们的差计算，第二次到达x后仍需额外一天到达x+1\n",
    "        # f(x + 1) = f(x) + f(x) - f(nextVisit[x]) + 2\n",
    "        dp = [0] * len(nextVisit)\n",
    "        dp[0] = 1\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i-1]] + 2) % (10 ** 9 + 7)\n",
    "        return (dp[-1] - 1) % (10 ** 9 + 7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        n = len(nextVisit)\n",
    "        dp = [0]*n\n",
    "        \n",
    "        for i in range(1, n):\n",
    "            dp[i] = (2*dp[i-1]-dp[nextVisit[i-1]]+2)%(10**9+7)\n",
    "        return dp[-1]%(10**9+7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "\n",
    "\n",
    "        # 到达第x+1房间需要先到达第x房间两次，\n",
    "        # 第一次到达x后需要额外一天到达nextVisit[x]，\n",
    "        # 从nextVisit[x]到达x可以用他们的差计算，\n",
    "        # 第二次到达x后仍需额外一天到达x+1\n",
    "        # f(x + 1) = f(x) + f(x) - f(nextVisit[x]) + 1 + 1\n",
    "\n",
    "\n",
    "        dp = [0] * len(nextVisit)\n",
    "\n",
    "        dp[0] = 1\n",
    "\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i - 1]] + 2) % ( 10 ** 9 + 7)\n",
    "\n",
    "        return (dp[-1] - 1) % (10 ** 9 + 7)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "kmod = 10**9 + 7\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        n = len(nextVisit)\n",
    "        dp = [0] * n\n",
    "        dp[0] = 1\n",
    "        for i in range(1, n):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i - 1]] + 2) % kmod\n",
    "        \n",
    "        return (dp[-1] - 1) % kmod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "\n",
    "\n",
    "        dp = [0] * len(nextVisit)\n",
    "\n",
    "        dp[0] = 1\n",
    "\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i - 1]] + 2) % ( 10 ** 9 + 7)\n",
    "\n",
    "        return (dp[-1] - 1) % (10 ** 9 + 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "\n",
    "        n = len(nextVisit)\n",
    "        dp = [0] * n\n",
    "        mod = 10 ** 9 + 7\n",
    "        for i in range(1, n):\n",
    "\n",
    "            dp[i] = 2 * dp[i - 1] - dp[nextVisit[i - 1]] + 2\n",
    "            dp[i] %= mod\n",
    "        return dp[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        mod = 10**9+7\n",
    "        n = len(nextVisit)\n",
    "        dp = [0]*n\n",
    "        for i in range(1, n):\n",
    "            dp[i] = (dp[i-1]*2+2-dp[nextVisit[i-1]])%mod\n",
    "        return dp[n-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        dp = [0] * len(nextVisit)\n",
    "        dp[0] = 1\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i-1]] + 2) % (10 ** 9 + 7)\n",
    "        return (dp[-1] - 1) % (10 ** 9 + 7)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        \n",
    "        mod = 10**9 + 7\n",
    "        n = len(nextVisit)\n",
    "        dp = [0] * n\n",
    "        dp[0] = 0\n",
    "\n",
    "        for i in range(1,n):\n",
    "            dp[i] = (2* dp[i-1] + 2 - dp[nextVisit[i-1]])%mod\n",
    "\n",
    "        return dp[-1]\n",
    "                \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        #[0 0 0 0 0 0 0 0 0 0]\n",
    "        #[2 1]\n",
    "        #访问完第i间房间用了visit[i] = visit[i - 1]*2 - visit[next[i - 1]] + 1\n",
    "        #visit[i] = visit[i-1] + (visit[i-1]-visit[next[i-1]]+1) + 1\n",
    "        #每天访问房间的顺序queue[i] = queue[i - 1]的次数为ji =nextvisit[i - 1]\n",
    "        #\n",
    "        n = len(nextVisit)                                                \n",
    "        visit = [-1] * (n)\n",
    "        visit[0] = 0\n",
    "        for i in range(1, n):\n",
    "            visit[i] = (visit[i - 1] + visit[i - 1] - visit[nextVisit[i - 1]] + 2 + 1000000007) % 1000000007\n",
    "        return visit[n - 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "\n",
    "\n",
    "\n",
    "        dp = [0] * len(nextVisit)\n",
    "\n",
    "        dp[0] = 1\n",
    "\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i] = (dp[i - 1] * 2 - dp[nextVisit[i - 1]] + 2) % ( 10 ** 9 + 7)\n",
    "\n",
    "        return (dp[-1] - 1) % (10 ** 9 + 7)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        MO = int(1e9 + 7)\n",
    "        n = len(nextVisit)\n",
    "        f = [0 for i in range(n)]\n",
    "        for i in range(1, n):\n",
    "            f[i] = (f[i - 1] + 1 + f[i - 1] - f[nextVisit[i - 1]] + 1 + MO) % MO\n",
    "        \n",
    "        return f[n - 1] % MO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        f = [1, 3]\n",
    "        n = len(nextVisit)\n",
    "        mod = 10 ** 9 + 7\n",
    "        for index in range(2, n):\n",
    "            f.append((f[index - 1] + f[index - 1] - f[nextVisit[index - 1]] + 2) % mod)\n",
    "        \n",
    "        res = f[-1] - 1\n",
    "        if res < 0:\n",
    "            res += mod\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "MOD = 10 ** 9 + 7\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        n = len(nextVisit)\n",
    "        # 从i到nextVisit[i]的固定时间长度\n",
    "        dp = [0 for _ in range(n)]\n",
    "        for i in range(1, n):\n",
    "            # 先跳回next[i-1]位置 然后从next[i-1]位置回到i-1位置\n",
    "            # 这个从next[i-1]到i-1的过程是重复的 我们可以使用dp[i-1]-dp[next[i-1]]直接计算得到\n",
    "            # 因为第一到达i位置时候 前面的位置一定是偶数次访问 不然是无法前进的\n",
    "            dp[i] = (2 + 2 * dp[i - 1] - dp[nextVisit[i - 1]]) % MOD\n",
    "            # 从next\n",
    "        return dp[n - 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        MOD = 10 ** 9 + 7\n",
    "        n = len(nextVisit)\n",
    "        prefix = [0] * (n+1)\n",
    "        for i , j in enumerate(nextVisit):\n",
    "            f = (2 + prefix[i] - prefix[j] + MOD) % MOD\n",
    "            prefix[i+1] = (prefix[i] + f ) % MOD\n",
    "        return prefix[-2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        mod = 1000000007\n",
    "        n = len(nextVisit)\n",
    "        dp = [0 for _ in range(n)]\n",
    "        dp[0] = 0\n",
    "        for i in range(1, n):\n",
    "            dp[i] = (2 * dp[i-1] - dp[nextVisit[i-1]] + 2) % mod\n",
    "        return dp[-1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        mod = 1000000007\n",
    "        n = len(nextVisit)\n",
    "        dp = [0 for _ in range(n)]\n",
    "        dp[0] = 0\n",
    "        for i in range(1, n):\n",
    "            dp[i] = (2 * dp[i-1] - dp[nextVisit[i-1]] + 2) % mod\n",
    "        return dp[-1]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        dp, mod = [0, 2], 10 ** 9 + 7\n",
    "        for i in range(1, len(nextVisit) - 1):\n",
    "            dp.append((dp[-1] * 2 + 2 - dp[nextVisit[i]]) % mod)\n",
    "        return dp[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    MOD = 1000000007\n",
    "\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        w = len(nextVisit)\n",
    "        memo = [0]*w\n",
    "        accum = [0]*(w+1)\n",
    "        for i in range(w):\n",
    "            memo[i] += accum[i]-accum[nextVisit[i]]+(i-nextVisit[i])\n",
    "            memo[i] += 1\n",
    "            memo[i] += self.MOD\n",
    "            memo[i] %= self.MOD\n",
    "            accum[i+1] = accum[i]+memo[i]\n",
    "        return (accum[w-1]+w-1) % self.MOD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        m = 10**9 + 7\n",
    "        dp = [[0, 0] for _ in range(len(nextVisit))]\n",
    "        dp[0] = [0, 1]\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i][0] = (dp[i - 1][1] + 1) % m\n",
    "            dp[i][1] = (2 * dp[i][0] - dp[nextVisit[i]][0] + 1) % m\n",
    "        return dp[-1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        m = 10**9 + 7\n",
    "        dp = [[0, 0] for _ in range(len(nextVisit))]\n",
    "        dp[0] = [0, 1]\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i][0] = (dp[i - 1][1] + 1) % m\n",
    "            dp[i][1] = (2 * dp[i][0] - dp[nextVisit[i]][0] + 1) % m\n",
    "        return dp[-1][0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        m = 10**9 + 7\n",
    "        dp = [[0, 0] for _ in range(len(nextVisit))]\n",
    "        dp[0] = [0, 1]\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i][0] = (dp[i - 1][1] + 1) % m\n",
    "            dp[i][1] = (2 * dp[i][0] - dp[nextVisit[i]][0] + 1) % m\n",
    "        return dp[-1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        m = 10**9 + 7\n",
    "        dp = [[0, 0] for _ in range(len(nextVisit))]\n",
    "        dp[0] = [0, 1]\n",
    "        for i in range(1, len(nextVisit)):\n",
    "            dp[i][0] = (dp[i - 1][1] + 1) % m\n",
    "            dp[i][1] = (2 * dp[i][0] - dp[nextVisit[i]][0] + 1) % m\n",
    "        return dp[-1][0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def firstDayBeenInAllRooms(self, nextVisit: List[int]) -> int:\n",
    "        n = len(nextVisit)\n",
    "\n",
    "        MOD = int(1e9) + 7\n",
    "\n",
    "        @cache\n",
    "        def dp(idx):\n",
    "            if idx < 0:\n",
    "                return 0\n",
    "\n",
    "            ret = dp(idx - 1)\n",
    "\n",
    "            if nextVisit[idx] != idx:\n",
    "                ret += 2 + dp(idx - 1) - dp(nextVisit[idx] - 1)\n",
    "            else:\n",
    "                ret += 2\n",
    "\n",
    "            return ret % MOD\n",
    "\n",
    "        return dp(n - 2)"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}
